"""文件工具模块
处理用户脚本的文件系统存储
"""
import os
import shutil
import logging
import json
import traceback
from pathlib import Path
from config import get_config
from services.shared.log_utils import log_error, log_info, log_system_event

# 获取日志记录器
logger = logging.getLogger(__name__)

def get_user_script_directory(username):
    """
    获取用户脚本目录路径
    
    Args:
        username (str): 用户名
        
    Returns:
        str: 用户脚本目录路径
    """
    config = get_config()
    # 优先使用配置中的脚本目录路径
    if config.USER_SCRIPTS_DIR:
        base_dir = Path(config.USER_SCRIPTS_DIR)
        logger.debug(f"使用配置的脚本目录路径: {base_dir}")
    else:
        # 使用默认路径
        base_dir = Path(__file__).parent.parent.parent / "user_scripts"
        logger.debug(f"使用默认脚本目录路径: {base_dir}")
    
    user_dir = base_dir / username
    logger.info(f"用户 {username} 的脚本目录路径: {user_dir}")
    return str(user_dir.resolve())

def create_user_script_directory(username):
    """
    为用户创建脚本目录
    
    Args:
        username (str): 用户名
        
    Returns:
        str: 用户脚本目录路径
    """
    user_dir = get_user_script_directory(username)
    try:
        os.makedirs(user_dir, exist_ok=True)
        logger.info(f"已创建用户 {username} 的脚本目录: {user_dir}")
    except Exception as e:
        logger.error(f"创建用户 {username} 的脚本目录失败: {str(e)}")
        
        # 记录详细的系统错误日志
        log_error(
            "file_utils_create_user_directory_failed",
            {
                "username": username,
                "user_dir": user_dir,
                "error_type": type(e).__name__,
                "error_message": str(e),
                "stack_trace": traceback.format_exc(),
                "execution_context": {
                    "function": "create_user_script_directory",
                    "module": "shared.file_utils",
                    "operation": "directory_creation"
                }
            }
        )
        raise
    return user_dir

def save_user_script(username, script_name, content, folder_path=None):
    """
    保存用户脚本到文件系统
    
    Args:
        username (str): 用户名
        script_name (str): 脚本名称
        content (str): 脚本内容
        folder_path (str, optional): 文件夹路径，如果提供则保存到指定文件夹
        
    Returns:
        str: 脚本文件路径
    """
    try:
        # 获取用户根目录
        user_dir = create_user_script_directory(username)
        logger.info(f"用户根目录: {user_dir}")
        
        # 处理脚本名称，确保有正确的扩展名
        if not script_name.endswith('.py'):
            script_name_with_ext = f"{script_name}.py"
        else:
            script_name_with_ext = script_name
        
        # 确定最终的脚本保存路径
        if folder_path:
            logger.info(f"将脚本保存到指定文件夹: {folder_path}")
            
            # 检查folder_path是否已经是绝对路径
            if os.path.isabs(folder_path):
                # 如果是绝对路径，直接使用
                target_dir = folder_path
                logger.info(f"使用绝对路径: {target_dir}")
            else:
                # 如果是相对路径，构建完整路径
                target_dir = os.path.join(user_dir, folder_path)
                logger.info(f"构建完整路径: {target_dir}")
        else:
            # 如果没有提供文件夹路径，则保存到用户根目录
            target_dir = user_dir
            logger.info(f"将脚本保存到用户根目录: {target_dir}")
        
        # 确保目标目录存在
        os.makedirs(target_dir, exist_ok=True)
        
        # 构建最终的脚本路径
        script_path = os.path.join(target_dir, script_name_with_ext)
        logger.info(f"脚本完整路径: {script_path}")
        
        # 写入脚本内容
        with open(script_path, 'w', encoding='utf-8') as f:
            f.write(content)
        
        logger.info(f"已保存用户 {username} 的脚本 {script_name} 到 {script_path}")
        return script_path
    except Exception as e:
        logger.error(f"保存用户 {username} 的脚本 {script_name} 失败: {str(e)}")
        
        # 记录详细的系统错误日志
        log_error(
            "file_utils_save_user_script_failed",
            {
                "username": username,
                "script_name": script_name,
                "folder_path": folder_path,
                "target_dir": locals().get('target_dir', 'unknown'),
                "script_path": locals().get('script_path', 'unknown'),
                "content_length": len(content) if content else 0,
                "error_type": type(e).__name__,
                "error_message": str(e),
                "stack_trace": traceback.format_exc(),
                "execution_context": {
                    "function": "save_user_script",
                    "module": "shared.file_utils",
                    "operation": "script_save"
                }
            }
        )
        raise

def get_user_script_path(username, script_name, folder_path=None):
    """
    获取用户脚本文件路径
    
    Args:
        username (str): 用户名
        script_name (str): 脚本名称
        folder_path (str, optional): 文件夹路径，如果提供则返回该文件夹下的脚本路径
        
    Returns:
        str: 脚本文件路径
    """
    # 确保脚本名称有.py扩展名
    if not script_name.endswith('.py'):
        script_name = f"{script_name}.py"
    
    if folder_path:
        # 检查folder_path是否已经是绝对路径
        if os.path.isabs(folder_path):
            # 如果是绝对路径，直接使用
            script_path = os.path.join(folder_path, script_name)
            logger.debug(f"获取脚本路径（绝对路径）: {script_path}")
        else:
            # 如果是相对路径，则相对于用户根目录
            user_dir = get_user_script_directory(username)
            script_path = os.path.join(user_dir, folder_path, script_name)
            logger.debug(f"获取脚本路径（相对路径）: {script_path}")
    else:
        # 否则返回用户根目录下的脚本路径
        user_dir = get_user_script_directory(username)
        script_path = os.path.join(user_dir, script_name)
        logger.debug(f"获取脚本路径（用户根目录）: {script_path}")
    return script_path

def delete_user_script_file(username, script_name, folder_path=None):
    """
    删除用户脚本文件
    
    Args:
        username (str): 用户名
        script_name (str): 脚本名称
        folder_path (str, optional): 文件夹路径，如果提供则删除该文件夹下的脚本
    """
    try:
        script_path = get_user_script_path(username, script_name, folder_path)
        if os.path.exists(script_path):
            logger.info(f"删除脚本文件: {script_path}")
            os.remove(script_path)
            
            # 记录成功删除的系统事件
            log_system_event(
                "INFO",
                "file_utils",
                "脚本文件删除成功",
                {
                    "username": username,
                    "script_name": script_name,
                    "folder_path": folder_path,
                    "script_path": script_path,
                    "operation": "script_deletion"
                }
            )
        else:
            logger.warning(f"脚本文件不存在，无法删除: {script_path}")
            
            # 记录文件不存在的警告事件
            log_system_event(
                "WARNING",
                "file_utils",
                "脚本文件不存在，无法删除",
                {
                    "username": username,
                    "script_name": script_name,
                    "folder_path": folder_path,
                    "script_path": script_path,
                    "operation": "script_deletion_attempt"
                }
            )
    except Exception as e:
        logger.error(f"删除用户 {username} 的脚本 {script_name} 失败: {str(e)}")
        
        # 记录详细的系统错误日志
        log_error(
            "file_utils_delete_user_script_failed",
            {
                "username": username,
                "script_name": script_name,
                "folder_path": folder_path,
                "script_path": locals().get('script_path', 'unknown'),
                "error_type": type(e).__name__,
                "error_message": str(e),
                "stack_trace": traceback.format_exc(),
                "execution_context": {
                    "function": "delete_user_script_file",
                    "module": "shared.file_utils",
                    "operation": "script_deletion"
                }
            }
        )
        raise

def list_user_scripts(username):
    """
    列出用户的所有脚本文件
    
    Args:
        username (str): 用户名
        
    Returns:
        list: 脚本文件名列表
    """
    user_dir = get_user_script_directory(username)
    if not os.path.exists(user_dir):
        return []
    
    scripts = []
    for file in os.listdir(user_dir):
        if file.endswith('.py'):
            scripts.append(file[:-3])  # 去掉.py后缀
    
    return scripts

def read_user_script_content(username, script_name, folder_path=None):
    """
    读取用户脚本内容
    
    Args:
        username (str): 用户名
        script_name (str): 脚本名称
        folder_path (str, optional): 文件夹路径，如果提供则从该文件夹读取脚本
        
    Returns:
        str: 脚本内容，如果文件不存在则返回None
    """
    script_path = get_user_script_path(username, script_name, folder_path)
    if not os.path.exists(script_path):
        logger.warning(f"用户 {username} 的脚本 {script_name} 不存在: {script_path}")
        return None
    
    try:
        with open(script_path, 'r', encoding='utf-8') as f:
            content = f.read()
        logger.debug(f"已读取用户 {username} 的脚本 {script_name} 内容")
        
        # 记录成功读取的系统事件
        log_system_event(
            "INFO",
            "file_utils",
            "脚本内容读取成功",
            {
                "username": username,
                "script_name": script_name,
                "script_path": script_path,
                "content_length": len(content),
                "operation": "script_read"
            }
        )
        return content
    except Exception as e:
        logger.error(f"读取用户 {username} 的脚本 {script_name} 失败: {str(e)}")
        
        # 记录详细的系统错误日志
        log_error(
            "file_utils_read_user_script_failed",
            {
                "username": username,
                "script_name": script_name,
                "script_path": script_path,
                "error_type": type(e).__name__,
                "error_message": str(e),
                "stack_trace": traceback.format_exc(),
                "execution_context": {
                    "function": "read_user_script_content",
                    "module": "shared.file_utils",
                    "operation": "script_read"
                }
            }
        )
        raise